home *** CD-ROM | disk | FTP | other *** search
/ Sound Fx / Sound Fx.iso / Software / UNZIPED / MPW181-5 / _SETUP.1 / layer3.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-19  |  37.7 KB  |  1,211 lines
  1. /* layer3.cpp
  2.  
  3.     Implementation of the layer III decoder
  4.  
  5.    01/31/97 : Layer III routines adopted from the ISO MPEG Audio Subgroup
  6.    Software Simulation Group's public c source for its MPEG audio decoder.
  7.    These routines were in the file "decoder.c". Rearrangement of the routines
  8.    as member functions of a layer III decoder object, and optimizations by
  9.    Jeff Tsay (ctsay@pasteur.eecs.berkeley.edu).
  10.  
  11.    04/14/97 : Several performance improvements. Inverse IMDCT moved to
  12.    an external source file. No huffman tables needed, so no need for
  13.    initialization. Put get_side_info() in this source file, and made
  14.    one function inline for better speed and elegance. Also added support
  15.    for mono decoding of stereo streams as well as downmixing. Bug fix
  16.    in dequantize_samples(). */
  17.  
  18. #ifdef  __WIN32__
  19. #define STRICT
  20. #include <windows.h>
  21. #endif   // __WIN32__
  22.  
  23. #include <math.h>
  24.  
  25. #include "all.h"
  26. #include "l3type.h"
  27. #include "ibitstr.h"
  28. #include "obuffer.h"
  29. #include "bit_res.h"
  30. #include "header.h"
  31. #include "synfilt.h"
  32. #include "huffman.h"
  33. #include "layer3.h"
  34. #include "inv_mdct.h"
  35.  
  36. LayerIII_Decoder::LayerIII_Decoder(Ibitstream *stream0,
  37.                                    Header *header0,
  38.                                    SynthesisFilter *filtera,
  39.                                    SynthesisFilter *filterb,
  40.                                            Obuffer *buffer0,
  41.                                    enum e_channels which_ch0)
  42. {
  43.   stream         = stream0;
  44.   header         = header0;
  45.   filter1        = filtera;
  46.   filter2        = filterb;
  47.   buffer         = buffer0;
  48.   which_channels = which_ch0;
  49.  
  50.   frame_start = 0;
  51.   channels    = (header->mode() == single_channel) ? 1 : 2;
  52.   max_gr      = (header->version() == MPEG1) ? 2 : 1;
  53.  
  54.   if (channels == 2) {
  55.  
  56.         switch (which_channels) {
  57.  
  58.      case left:
  59.      case downmix:
  60.      first_channel = last_channel = 0;
  61.      break;
  62.  
  63.      case right:
  64.      first_channel = last_channel = 1;
  65.      break;
  66.  
  67.      case both:
  68.      first_channel  = 0;
  69.      last_channel   = 1;
  70.      break;
  71.  
  72.       default:
  73.      // uh oh
  74.      break;
  75.  
  76.      }
  77.   } else {
  78.  
  79.     first_channel = last_channel = 0;
  80.   }
  81.  
  82.   for(uint32 i=0;i<2;i++)
  83.           for(uint32 j=0;j<SBLIMIT;j++)
  84.               for(uint32 k=0;k<SSLIMIT;k++)
  85.                   prevblck[i][j][k] = 0.0f;
  86.  
  87.   br = new Bit_Reserve();
  88.   si = new III_side_info_t;
  89. }
  90.  
  91. LayerIII_Decoder::~LayerIII_Decoder()
  92. {
  93.    delete br;
  94.    delete si;
  95. }
  96.  
  97. void LayerIII_Decoder::seek_notify()
  98. {
  99.     frame_start = 0;
  100.  
  101.       for(uint32 i=0;i<2;i++)
  102.           for(uint32 j=0;j<SBLIMIT;j++)
  103.               for(uint32 k=0;k<SSLIMIT;k++)
  104.                   prevblck[i][j][k]=0.0f;
  105.  
  106.    delete br;
  107.    br = new Bit_Reserve;
  108. }
  109.  
  110.  
  111. BOOL LayerIII_Decoder::get_side_info()
  112. // Reads the side info from the stream, assuming the entire
  113. // frame has been read already.
  114.  
  115. // Mono   : 136 bits (= 17 bytes)
  116. // Stereo : 256 bits (= 32 bytes)
  117.  
  118. {
  119.     if (header->version() == MPEG1) {
  120.  
  121.         si->main_data_begin = stream->get_bits(9);
  122.         if (channels == 1)
  123.             si->private_bits = stream->get_bits(5);
  124.         else si->private_bits = stream->get_bits(3);
  125.  
  126.         for (uint32 ch=0; ch<channels; ch++) {
  127.             si->ch[ch].scfsi[0] = stream->get_bits(1);
  128.             si->ch[ch].scfsi[1] = stream->get_bits(1);
  129.             si->ch[ch].scfsi[2] = stream->get_bits(1);
  130.             si->ch[ch].scfsi[3] = stream->get_bits(1);
  131.        }
  132.  
  133.         for (uint32 gr=0; gr<2; gr++) {
  134.             for (uint32 ch=0; ch<channels; ch++) {
  135.                 si->ch[ch].gr[gr].part2_3_length = stream->get_bits(12);
  136.                   si->ch[ch].gr[gr].big_values = stream->get_bits(9);
  137.                 si->ch[ch].gr[gr].global_gain = stream->get_bits(8);
  138.                 si->ch[ch].gr[gr].scalefac_compress = stream->get_bits(4);
  139.                 si->ch[ch].gr[gr].window_switching_flag = stream->get_bits(1);
  140.                 if (si->ch[ch].gr[gr].window_switching_flag) {
  141.                     si->ch[ch].gr[gr].block_type       = stream->get_bits(2);
  142.                     si->ch[ch].gr[gr].mixed_block_flag = stream->get_bits(1);
  143.  
  144.                     si->ch[ch].gr[gr].table_select[0]  = stream->get_bits(5);
  145.                     si->ch[ch].gr[gr].table_select[1]  = stream->get_bits(5);
  146.  
  147.                     si->ch[ch].gr[gr].subblock_gain[0] = stream->get_bits(3);
  148.                     si->ch[ch].gr[gr].subblock_gain[1] = stream->get_bits(3);
  149.                     si->ch[ch].gr[gr].subblock_gain[2] = stream->get_bits(3);
  150.  
  151.                     // Set region_count parameters since they are implicit in this case.
  152.  
  153.                     if (si->ch[ch].gr[gr].block_type == 0) {
  154.                         //     Side info bad: block_type == 0 in split block
  155.                         return(FALSE);
  156.                     } else if (si->ch[ch].gr[gr].block_type == 2
  157.                                     && si->ch[ch].gr[gr].mixed_block_flag == 0) {
  158.                         si->ch[ch].gr[gr].region0_count = 8;
  159.                } else {
  160.                    si->ch[ch].gr[gr].region0_count = 7;
  161.                }
  162.                     si->ch[ch].gr[gr].region1_count = 20 -
  163.                             si->ch[ch].gr[gr].region0_count;
  164.                 } else {
  165.                     si->ch[ch].gr[gr].table_select[0] = stream->get_bits(5);
  166.                     si->ch[ch].gr[gr].table_select[1] = stream->get_bits(5);
  167.                     si->ch[ch].gr[gr].table_select[2] = stream->get_bits(5);
  168.                     si->ch[ch].gr[gr].region0_count = stream->get_bits(4);
  169.                     si->ch[ch].gr[gr].region1_count = stream->get_bits(3);
  170.                     si->ch[ch].gr[gr].block_type = 0;
  171.                 }
  172.                 si->ch[ch].gr[gr].preflag = stream->get_bits(1);
  173.                 si->ch[ch].gr[gr].scalefac_scale = stream->get_bits(1);
  174.                 si->ch[ch].gr[gr].count1table_select = stream->get_bits(1);
  175.          }
  176.       }
  177.  
  178.    } else {      // MPEG-2 LSF
  179.  
  180.       si->main_data_begin = stream->get_bits(8);
  181.       if (channels == 1)
  182.           si->private_bits = stream->get_bits(1);
  183.       else si->private_bits = stream->get_bits(2);
  184.  
  185.  
  186.       for (uint32 ch=0; ch<channels; ch++) {
  187.  
  188.           si->ch[ch].gr[0].part2_3_length = stream->get_bits(12);
  189.           si->ch[ch].gr[0].big_values = stream->get_bits(9);
  190.           si->ch[ch].gr[0].global_gain = stream->get_bits(8);
  191.           si->ch[ch].gr[0].scalefac_compress = stream->get_bits(9);
  192.           si->ch[ch].gr[0].window_switching_flag = stream->get_bits(1);
  193.  
  194.           if (si->ch[ch].gr[0].window_switching_flag) {
  195.  
  196.              si->ch[ch].gr[0].block_type = stream->get_bits(2);
  197.              si->ch[ch].gr[0].mixed_block_flag = stream->get_bits(1);
  198.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  199.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  200.  
  201.              si->ch[ch].gr[0].subblock_gain[0] = stream->get_bits(3);
  202.              si->ch[ch].gr[0].subblock_gain[1] = stream->get_bits(3);
  203.              si->ch[ch].gr[0].subblock_gain[2] = stream->get_bits(3);
  204.  
  205.             // Set region_count parameters since they are implicit in this case.
  206.  
  207.              if (si->ch[ch].gr[0].block_type == 0) {
  208.                 // Side info bad: block_type == 0 in split block
  209.                 return(FALSE);
  210.              } else if (si->ch[ch].gr[0].block_type == 2
  211.                       && si->ch[ch].gr[0].mixed_block_flag == 0) {
  212.                   si->ch[ch].gr[0].region0_count = 8;
  213.                  } else {
  214.                   si->ch[ch].gr[0].region0_count = 7;
  215.                 si->ch[ch].gr[0].region1_count = 20 -
  216.                                                             si->ch[ch].gr[0].region0_count;
  217.              }
  218.  
  219.           } else {
  220.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  221.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  222.              si->ch[ch].gr[0].table_select[2] = stream->get_bits(5);
  223.              si->ch[ch].gr[0].region0_count = stream->get_bits(4);
  224.              si->ch[ch].gr[0].region1_count = stream->get_bits(3);
  225.              si->ch[ch].gr[0].block_type = 0;
  226.           }
  227.  
  228.           si->ch[ch].gr[0].scalefac_scale = stream->get_bits(1);
  229.           si->ch[ch].gr[0].count1table_select = stream->get_bits(1);
  230.       }   // for(ch=0; ch<channels; ch++)
  231.    } // if (header->version() == MPEG1)
  232.     return(TRUE);
  233. }
  234.  
  235. struct {
  236.     int32 l[5];
  237.     int32 s[3];} sfbtable = {{0, 6, 11, 16, 21},
  238.                                     {0, 6, 12}};
  239.  
  240. int32 slen[2][16] = {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  241.                      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
  242.  
  243. void LayerIII_Decoder::get_scale_factors(uint32 ch, uint32 gr)
  244. {
  245.     int32 sfb, window;
  246.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  247.    int32 scale_comp   = gr_info->scalefac_compress;
  248.    int32 length0      = slen[0][scale_comp];
  249.    int32 length1      = slen[1][scale_comp];
  250.  
  251.      if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  252.         if (gr_info->mixed_block_flag) { // MIXED  -  NEW - ag 11/25
  253.             for (sfb = 0; sfb < 8; sfb++)
  254.                 scalefac[ch].l[sfb] = br->hgetbits(
  255.                       slen[0][gr_info->scalefac_compress]);
  256.             for (sfb = 3; sfb < 6; sfb++)
  257.                 for (window=0; window<3; window++)
  258.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  259.                       slen[0][gr_info->scalefac_compress]);
  260.             for (sfb = 6; sfb < 12; sfb++)
  261.                 for (window=0; window<3; window++)
  262.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  263.                       slen[1][gr_info->scalefac_compress]);
  264.             for (sfb=12,window=0; window<3; window++)
  265.                 scalefac[ch].s[window][sfb] = 0;
  266.         }
  267.         else {  // SHORT
  268.  
  269.          scalefac[ch].s[0][0]  = br->hgetbits(length0);
  270.          scalefac[ch].s[1][0]  = br->hgetbits(length0);
  271.          scalefac[ch].s[2][0]  = br->hgetbits(length0);
  272.          scalefac[ch].s[0][1]  = br->hgetbits(length0);
  273.          scalefac[ch].s[1][1]  = br->hgetbits(length0);
  274.          scalefac[ch].s[2][1]  = br->hgetbits(length0);
  275.          scalefac[ch].s[0][2]  = br->hgetbits(length0);
  276.          scalefac[ch].s[1][2]  = br->hgetbits(length0);
  277.          scalefac[ch].s[2][2]  = br->hgetbits(length0);
  278.          scalefac[ch].s[0][3]  = br->hgetbits(length0);
  279.          scalefac[ch].s[1][3]  = br->hgetbits(length0);
  280.          scalefac[ch].s[2][3]  = br->hgetbits(length0);
  281.          scalefac[ch].s[0][4]  = br->hgetbits(length0);
  282.          scalefac[ch].s[1][4]  = br->hgetbits(length0);
  283.          scalefac[ch].s[2][4]  = br->hgetbits(length0);
  284.          scalefac[ch].s[0][5]  = br->hgetbits(length0);
  285.          scalefac[ch].s[1][5]  = br->hgetbits(length0);
  286.          scalefac[ch].s[2][5]  = br->hgetbits(length0);
  287.          scalefac[ch].s[0][6]  = br->hgetbits(length1);
  288.          scalefac[ch].s[1][6]  = br->hgetbits(length1);
  289.          scalefac[ch].s[2][6]  = br->hgetbits(length1);
  290.          scalefac[ch].s[0][7]  = br->hgetbits(length1);
  291.          scalefac[ch].s[1][7]  = br->hgetbits(length1);
  292.          scalefac[ch].s[2][7]  = br->hgetbits(length1);
  293.          scalefac[ch].s[0][8]  = br->hgetbits(length1);
  294.          scalefac[ch].s[1][8]  = br->hgetbits(length1);
  295.          scalefac[ch].s[2][8]  = br->hgetbits(length1);
  296.          scalefac[ch].s[0][9]  = br->hgetbits(length1);
  297.          scalefac[ch].s[1][9]  = br->hgetbits(length1);
  298.          scalefac[ch].s[2][9]  = br->hgetbits(length1);
  299.          scalefac[ch].s[0][10] = br->hgetbits(length1);
  300.          scalefac[ch].s[1][10] = br->hgetbits(length1);
  301.          scalefac[ch].s[2][10] = br->hgetbits(length1);
  302.          scalefac[ch].s[0][11] = br->hgetbits(length1);
  303.          scalefac[ch].s[1][11] = br->hgetbits(length1);
  304.          scalefac[ch].s[2][11] = br->hgetbits(length1);
  305.          scalefac[ch].s[0][12] = 0;
  306.             scalefac[ch].s[1][12] = 0;
  307.             scalefac[ch].s[2][12] = 0;
  308.  
  309.         }
  310.      }
  311.      else {   // LONG types 0,1,3
  312.  
  313.         if ((si->ch[ch].scfsi[0] == 0) || (gr == 0)) {
  314.            scalefac[ch].l[0]  = br->hgetbits(length0);
  315.            scalefac[ch].l[1]  = br->hgetbits(length0);
  316.            scalefac[ch].l[2]  = br->hgetbits(length0);
  317.            scalefac[ch].l[3]  = br->hgetbits(length0);
  318.            scalefac[ch].l[4]  = br->hgetbits(length0);
  319.            scalefac[ch].l[5]  = br->hgetbits(length0);
  320.           }
  321.         if ((si->ch[ch].scfsi[1] == 0) || (gr == 0)) {
  322.            scalefac[ch].l[6]  = br->hgetbits(length0);
  323.            scalefac[ch].l[7]  = br->hgetbits(length0);
  324.            scalefac[ch].l[8]  = br->hgetbits(length0);
  325.            scalefac[ch].l[9]  = br->hgetbits(length0);
  326.            scalefac[ch].l[10] = br->hgetbits(length0);
  327.           }
  328.         if ((si->ch[ch].scfsi[2] == 0) || (gr == 0)) {
  329.            scalefac[ch].l[11] = br->hgetbits(length1);
  330.            scalefac[ch].l[12] = br->hgetbits(length1);
  331.            scalefac[ch].l[13] = br->hgetbits(length1);
  332.            scalefac[ch].l[14] = br->hgetbits(length1);
  333.            scalefac[ch].l[15] = br->hgetbits(length1);
  334.           }
  335.         if ((si->ch[ch].scfsi[3] == 0) || (gr == 0)) {
  336.            scalefac[ch].l[16] = br->hgetbits(length1);
  337.            scalefac[ch].l[17] = br->hgetbits(length1);
  338.            scalefac[ch].l[18] = br->hgetbits(length1);
  339.            scalefac[ch].l[19] = br->hgetbits(length1);
  340.            scalefac[ch].l[20] = br->hgetbits(length1);
  341.           }
  342.  
  343.         scalefac[ch].l[21] = 0;
  344.           scalefac[ch].l[22] = 0;
  345.      }
  346. }
  347.  
  348. struct  {
  349.     int32 l[23];
  350.     int32 s[14];} sfBandIndex[3] =
  351.     {{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  352.       {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  353.      {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  354.       {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  355.      {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  356.       {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
  357.  
  358. void LayerIII_Decoder::huffman_decode(uint32 ch, uint32 gr)
  359. {
  360.     int32 i, x, y;
  361.     int32 v, w;
  362.    int32 part2_3_end = part2_start + si->ch[ch].gr[gr].part2_3_length;
  363.    int32 num_bits;
  364.     int32 region1Start;
  365.     int32 region2Start;
  366.    int32 sf_index;
  367.    int32 ssindex, sbindex;
  368.      struct huffcodetab *h;
  369.  
  370.     // Find region boundary for short block case
  371.  
  372.     if ( (si->ch[ch].gr[gr].window_switching_flag) &&
  373.           (si->ch[ch].gr[gr].block_type == 2) ) {
  374.  
  375.         // Region2.
  376.  
  377.         region1Start = 36;  // sfb[9/3]*3=36
  378.         region2Start = 576; // No Region2 for short block case
  379.     }
  380.  
  381.     else {          // Find region boundary for long block case
  382.  
  383.        sf_index = header->sample_frequency();
  384.  
  385.         region1Start = sfBandIndex[sf_index].l[si->ch[ch].gr[gr].region0_count
  386.                                              + 1]; /* MI */
  387.         region2Start = sfBandIndex[sf_index].l[si->ch[ch].gr[gr].region0_count +
  388.                                            si->ch[ch].gr[gr].region1_count + 2]; /* MI */
  389.         }
  390.  
  391.    sbindex = 0; ssindex = 0;
  392.     // Read bigvalues area
  393.     for (i=0; i<(si->ch[ch].gr[gr].big_values<<1); i+=2) {
  394.         if      (i<region1Start) h = &ht[si->ch[ch].gr[gr].table_select[0]];
  395.         else if (i<region2Start) h = &ht[si->ch[ch].gr[gr].table_select[1]];
  396.               else                h = &ht[si->ch[ch].gr[gr].table_select[2]];
  397.  
  398.         huffman_decoder(h, &x, &y, &v, &w, br);
  399.  
  400.       is[sbindex][ssindex]   = x;
  401.       is[sbindex][ssindex+1] = y;
  402.  
  403.       ssindex += 2;
  404.       if (ssindex >= SSLIMIT) {
  405.           ssindex = 0;
  406.          sbindex++;
  407.       }
  408.     }
  409.  
  410.     // Read count1 area
  411.     h = &ht[(*si).ch[ch].gr[gr].count1table_select+32];
  412.    num_bits = br->hsstell();
  413.  
  414.     while ((num_bits < part2_3_end) && (sbindex < SBLIMIT)) {
  415.  
  416.         huffman_decoder(h, &x, &y, &v, &w, br);
  417.       is[sbindex][ssindex]   = v;
  418.       is[sbindex][ssindex+1] = w;
  419.  
  420.       ssindex += 2;
  421.       if (ssindex >= SSLIMIT) {
  422.           ssindex = 0;
  423.          sbindex++;
  424.       }
  425.  
  426.         if (sbindex < SBLIMIT) {
  427.             is[sbindex][ssindex]   = x;
  428.             is[sbindex][ssindex+1] = y;
  429.       }
  430.  
  431.       ssindex += 2;
  432.       if (ssindex >= SSLIMIT) {
  433.           ssindex = 0;
  434.          sbindex++;
  435.       }
  436.       num_bits = br->hsstell();
  437.    }
  438.  
  439.     if (num_bits > part2_3_end) {
  440.         br->rewindNbits(num_bits - part2_3_end);
  441.       ssindex -= 4;
  442.       if (ssindex < 0) {
  443.           ssindex += SSLIMIT;
  444.          sbindex--;
  445.       }
  446.     }
  447.  
  448.    num_bits = br->hsstell();
  449.  
  450.     // Dismiss stuffing bits
  451.     if (num_bits < part2_3_end)
  452.        br->hgetbits(part2_3_end - num_bits);
  453.  
  454.     // Zero out rest
  455.    for (; ssindex < SSLIMIT; ssindex++)
  456.        is[sbindex][ssindex] = 0;
  457.  
  458.    sbindex++;
  459.  
  460.    for(; sbindex < SBLIMIT; sbindex++)
  461.        for(ssindex = 0; ssindex < SSLIMIT; ssindex+=3) {
  462.           is[sbindex][ssindex]   = 0;
  463.          is[sbindex][ssindex+1] = 0;
  464.          is[sbindex][ssindex+2] = 0;
  465.       }
  466. }
  467.  
  468. int32 pretab[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  469.  
  470. void LayerIII_Decoder::dequantize_sample(real xr[SBLIMIT][SSLIMIT],
  471.                                                      uint32 ch, uint32 gr)
  472. {
  473.    static real TO_FOUR_THIRDS[POW_TABLE_LIMIT];
  474.     static real two_to_negative_half_pow[40];
  475.    static BOOL Dequant_init = FALSE;
  476.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  477.     int32  ss, sb, cb=0, sfreq=header->sample_frequency();
  478.     int32  next_cb_boundary, cb_begin, cb_width;
  479.     int32  index=0, t_index;
  480.    int32 *is1d;
  481.    real   g_gain;
  482.    real  *xr1d;
  483.  
  484.    if (!Dequant_init) {
  485.  
  486.        uint32 i;
  487.  
  488.        for(i=0; i<POW_TABLE_LIMIT; i++)
  489.               TO_FOUR_THIRDS[i] = (real) pow((double) i, 4.0/3.0);
  490.  
  491.       for(i=0; i<40; i++)
  492.           two_to_negative_half_pow[i] = (real) pow(2.0, -0.5 * (double) i);
  493.  
  494.       Dequant_init = TRUE;
  495.    }
  496.  
  497.     // choose correct scalefactor band per block type, initalize boundary
  498.  
  499.     if (gr_info->window_switching_flag && (gr_info->block_type == 2) ) {
  500.         if (gr_info->mixed_block_flag)
  501.             next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  502.         else {
  503.          cb_width = sfBandIndex[sfreq].s[1];
  504.            next_cb_boundary = (cb_width << 2) - cb_width;
  505.             cb_begin = 0;
  506.         }
  507.     } else {
  508.         next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  509.    }
  510.  
  511.    // Compute overall (global) scaling.
  512.  
  513.     g_gain = (real) pow(2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  514.  
  515.    for (sb=0; sb < SBLIMIT; sb++) {
  516.  
  517.        is1d = is[sb];        xr1d = xr[sb];
  518.        for(ss=0; ss < SSLIMIT; ss++) {
  519.  
  520.           if (is1d[ss] == 0) {
  521.                 xr1d[ss] = 0.0f;
  522.          } else {
  523.              uint32 abv = abs(is1d[ss]);
  524.             if (abv < POW_TABLE_LIMIT)
  525.                xr1d[ss] = g_gain * TO_FOUR_THIRDS[abv];
  526.             else
  527.                 xr1d[ss] = g_gain * pow((double) abv, 1.333333333);
  528.  
  529.             if (is1d[ss] < 0)   xr1d[ss] = -xr1d[ss];
  530.          }
  531.       }
  532.     }
  533.  
  534.     // apply formula per block type
  535.  
  536.     for (sb=0; sb < SBLIMIT; sb++) {
  537.  
  538.         for (ss=0; ss < SSLIMIT; ss++) {
  539.  
  540.             if (index == next_cb_boundary)  { /* Adjust critical band boundary */
  541.                 if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  542.                     if (gr_info->mixed_block_flag)  {
  543.  
  544.                         if (index == sfBandIndex[sfreq].l[8])  {
  545.                      next_cb_boundary = sfBandIndex[sfreq].s[4];
  546.                      next_cb_boundary = (next_cb_boundary << 2) -
  547.                                             next_cb_boundary;
  548.                             cb = 3;
  549.                            cb_width = sfBandIndex[sfreq].s[4] -
  550.                                    sfBandIndex[sfreq].s[3];
  551.  
  552.                           cb_begin = sfBandIndex[sfreq].s[3];
  553.                      cb_begin = (cb_begin << 2) - cb_begin;
  554.                         }
  555.  
  556.                         else if (index < sfBandIndex[sfreq].l[8])
  557.                             next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  558.                         else {
  559.                       next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  560.                      next_cb_boundary = (next_cb_boundary << 2) -
  561.                                              next_cb_boundary;
  562.  
  563.                      cb_begin = sfBandIndex[sfreq].s[cb];
  564.                             cb_width = sfBandIndex[sfreq].s[cb+1] -
  565.                                 cb_begin;
  566.                      cb_begin = (cb_begin << 2) - cb_begin;
  567.                         }
  568.                     }
  569.                     else  {
  570.                   next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  571.                   next_cb_boundary = (next_cb_boundary << 2) -
  572.                                       next_cb_boundary;
  573.  
  574.                   cb_begin = sfBandIndex[sfreq].s[cb];
  575.                         cb_width = sfBandIndex[sfreq].s[cb+1] -
  576.                                cb_begin;
  577.                   cb_begin = (cb_begin << 2) - cb_begin;
  578.                     }
  579.                 }
  580.                 else // long blocks
  581.                     next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  582.             }
  583.  
  584.             // Do long/short dependent scaling operations
  585.  
  586.             if (gr_info->window_switching_flag &&
  587.                  (((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  588.                   ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (sb >= 2)) ))
  589.          {
  590.  
  591.                 t_index = (index - cb_begin) / cb_width;
  592.             xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info->subblock_gain[t_index])
  593.                                     -(0.5 * (1.0 + gr_info->scalefac_scale)
  594.                                       * scalefac[ch].s[t_index][cb])));
  595.             } else {   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
  596. /*                xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  597.                                                      * (scalefac[ch].l[cb]
  598.                                                      + gr_info->preflag * pretab[cb])); */
  599.                 uint32 idx = scalefac[ch].l[cb];
  600.  
  601.                if (gr_info->preflag)
  602.                    idx += pretab[cb];
  603.  
  604.                idx = idx << gr_info->scalefac_scale;
  605.  
  606.             xr[sb][ss] *= two_to_negative_half_pow[idx];
  607.             }
  608.          index++;
  609.         }
  610.    }
  611. }
  612.  
  613. void LayerIII_Decoder::reorder (real xr[SBLIMIT][SSLIMIT], uint32 ch, uint32 gr)
  614. {
  615.  
  616.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  617.     uint32 sfreq = (uint32) header->sample_frequency();
  618.    uint32 freq, freq3;
  619.     int32 sfb, sfb_start, sfb_lines;
  620.    int32 src_line, des_line;
  621.    real *ho, *xr1d;
  622.  
  623.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  624.  
  625.         for(uint32 sb=0;sb<SBLIMIT;sb++) {
  626.           ho = re_hybridOut[sb];
  627.          ho[0]  = 0.0f;        ho[1]  = 0.0f;        ho[2]  = 0.0f;
  628.          ho[3]  = 0.0f;        ho[4]  = 0.0f;        ho[5]  = 0.0f;
  629.          ho[6]  = 0.0f;        ho[7]  = 0.0f;        ho[8]  = 0.0f;
  630.          ho[9]  = 0.0f;        ho[10] = 0.0f;        ho[11] = 0.0f;
  631.          ho[12] = 0.0f;        ho[13] = 0.0f;        ho[14] = 0.0f;
  632.          ho[15] = 0.0f;        ho[16] = 0.0f;        ho[17] = 0.0f;
  633.         }
  634.  
  635.         if (gr_info->mixed_block_flag) {
  636.             // NO REORDER FOR LOW 2 SUBBANDS
  637.                for (uint32 ss=0; ss < SSLIMIT; ss+=3) {
  638.                     re_hybridOut[0][ss]   = xr[0][ss];
  639.                re_hybridOut[0][ss+1] = xr[0][ss+1];
  640.                re_hybridOut[0][ss+2] = xr[0][ss+2];
  641.             }
  642.  
  643.             for (uint32 ss=0; ss < SSLIMIT; ss+=3) {
  644.                 re_hybridOut[1][ss]   = xr[1][ss];
  645.                re_hybridOut[1][ss+1] = xr[1][ss+1];
  646.                re_hybridOut[1][ss+2] = xr[1][ss+2];
  647.             }
  648.  
  649.             // REORDERING FOR REST SWITCHED SHORT
  650.                 for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  651.                        sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  652.                        sfb < 13; sfb++,sfb_start = sfBandIndex[sfreq].s[sfb],
  653.                     (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  654.             {
  655.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  656.  
  657.                         for(freq=0, freq3=0; freq<sfb_lines;
  658.                       freq++, freq3+=3) {
  659.  
  660.                             src_line = sfb_start3 + freq;
  661.                             des_line = sfb_start3 + freq3;
  662.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  663.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  664.                             src_line += sfb_lines;
  665.                             des_line++;
  666.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  667.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  668.                             src_line += sfb_lines;
  669.                             des_line++;
  670.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  671.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  672.                        }
  673.             }
  674.         }
  675.         else {  // pure short
  676.             for(sfb=0,sfb_start=0,sfb_lines=sfBandIndex[sfreq].s[1];
  677.                 sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  678.                 (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  679.             {
  680.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  681.  
  682.                         for(freq=0, freq3=0; freq<sfb_lines;
  683.                       freq++, freq3+=3) {
  684.  
  685.                             src_line = sfb_start3 + freq;
  686.                             des_line = sfb_start3 + freq3;
  687.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  688.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  689.                             src_line += sfb_lines;
  690.                             des_line++;
  691.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  692.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  693.                             src_line += sfb_lines;
  694.                             des_line++;
  695.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  696.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  697.                        }
  698.             }
  699.         }
  700.     }
  701.     else {   // long blocks
  702.         for (uint32 sb=0; sb < SBLIMIT; sb++) {
  703.            ho = re_hybridOut[sb];        xr1d = xr[sb];
  704.          ho[0]  = xr1d[0];         ho[1]  = xr1d[1];
  705.          ho[2]  = xr1d[2];         ho[3]  = xr1d[3];
  706.          ho[4]  = xr1d[4];         ho[5]  = xr1d[5];
  707.          ho[6]  = xr1d[6];         ho[7]  = xr1d[7];
  708.          ho[8]  = xr1d[8];         ho[9]  = xr1d[9];
  709.          ho[10] = xr1d[10];        ho[11] = xr1d[11];
  710.          ho[12] = xr1d[12];        ho[13] = xr1d[13];
  711.          ho[14] = xr1d[14];        ho[15] = xr1d[15];
  712.          ho[16] = xr1d[16];        ho[17] = xr1d[17];
  713.       }
  714.     }
  715. }
  716.  
  717. real TAN12[16]={0.0, 0.26794919, 0.57735027, 1.0,
  718.                 1.73205081, 3.73205081, 9.9999999e10 /*unbounded*/, -3.73205081,
  719.                 -1.73205081, -1.0, -0.57735027, -0.26794919,
  720.                 0.0, 0.26794919, 0.57735027, 1.0};
  721.  
  722. void LayerIII_Decoder::stereo(uint32 gr)
  723. {
  724.     int32 is_pos[576];
  725.     real  is_ratio[576];
  726.     gr_info_s *gr_info = &(si->ch[0].gr[gr]);
  727.     uint32 sfreq    = (uint32) header->sample_frequency();
  728.    uint32 mode_ext = header->mode_extension();
  729.     int32 sfb;
  730.     int32 i, j;
  731.    int32 sb, ss;
  732.    int32 lines, temp, temp2;
  733.     BOOL ms_stereo = (header->mode() == joint_stereo) && (mode_ext & 0x2);
  734.     BOOL i_stereo  = (header->mode() == joint_stereo) && (mode_ext & 0x1);
  735.  
  736.     if  (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
  737.  
  738.         for(sb=0;sb<SBLIMIT;sb++)
  739.             for(ss=0;ss<SSLIMIT;ss+=3) {
  740.                 lr[0][sb][ss]   = ro[0][sb][ss];
  741.             lr[0][sb][ss+1] = ro[0][sb][ss+1];
  742.                 lr[0][sb][ss+2] = ro[0][sb][ss+2];
  743.          }
  744.  
  745.    } else {
  746.  
  747.      // initialization
  748.    for (i=0; i<576; i+=8) {
  749.       is_pos[i]   = 7; is_pos[i+1] = 7; is_pos[i+2] = 7; is_pos[i+3] = 7;
  750.       is_pos[i+4] = 7; is_pos[i+5] = 7; is_pos[i+6] = 7; is_pos[i+7] = 7;
  751.    }
  752.  
  753.     if (i_stereo)
  754.     {  if (gr_info->window_switching_flag && (gr_info->block_type == 2))
  755.         {  if (gr_info->mixed_block_flag)
  756.             {  int32 max_sfb = 0;
  757.  
  758.                 for (j=0; j<3; j++)
  759.                 {  int32 sfbcnt;
  760.                     sfbcnt = 2;
  761.                     for( sfb=12; sfb >=3; sfb-- )
  762.                     {
  763.                    i = sfBandIndex[sfreq].s[sfb];
  764.                         lines = sfBandIndex[sfreq].s[sfb+1] - i;
  765.                   i = (i << 2) - i + (j+1) * lines - 1;
  766.                         while ( lines > 0 )
  767.                         {  if ( ro[1][i/SSLIMIT][i%SSLIMIT] != 0.0f )
  768.                             {  sfbcnt = sfb;
  769.                                 sfb = -10;
  770.                                 lines = -10;
  771.                             }
  772.                             lines--;
  773.                             i--;
  774.                         }
  775.                     }
  776.                     sfb = sfbcnt + 1;
  777.  
  778.                     if (sfb > max_sfb)
  779.                         max_sfb = sfb;
  780.  
  781.                     while(sfb < 12)
  782.                     {    temp = sfBandIndex[sfreq].s[sfb];
  783.                    sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  784.                   i    = (temp << 2) - temp + j * sb;
  785.  
  786.                         for ( ; sb > 0; sb--)
  787.                         {  is_pos[i] = scalefac[1].s[j][sfb];
  788.                             if (is_pos[i] != 7)
  789.                         is_ratio[i] = TAN12[is_pos[i]];
  790.  
  791.                             i++;
  792.                         }
  793.                         sfb++;
  794.                     }
  795.                     sfb = sfBandIndex[sfreq].s[10];
  796.                sb  = sfBandIndex[sfreq].s[11] - sfb;
  797.                sfb = (sfb << 2) - sfb + j * sb;
  798.                temp  = sfBandIndex[sfreq].s[11];
  799.                sb = sfBandIndex[sfreq].s[12] - temp;
  800.                i = (temp << 2) - temp + j * sb;
  801.  
  802.                     for ( ; sb > 0; sb-- )
  803.                     {  is_pos[i] = is_pos[sfb];
  804.                         is_ratio[i] = is_ratio[sfb];
  805.                         i++;
  806.                     }
  807.                  }
  808.                  if (max_sfb <= 3)
  809.                  {  i = 2;
  810.                      ss = 17;
  811.                      sb = -1;
  812.                      while (i >= 0)
  813.                      {  if (ro[1][i][ss] != 0.0f)
  814.                          {
  815.                         sb = (i<<4) + (i<<1) + ss;
  816.                              i = -1;
  817.                          } else
  818.                          {  ss--;
  819.                              if (ss < 0)
  820.                              {  i--;
  821.                                  ss = 17;
  822.                              }
  823.                          }
  824.                      }
  825.                      i = 0;
  826.                      while ( sfBandIndex[sfreq].l[i] <= sb )
  827.                          i++;
  828.                      sfb = i;
  829.                      i = sfBandIndex[sfreq].l[i];
  830.                      for (; sfb<8; sfb++)
  831.                      {  sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  832.                          for (; sb>0; sb--)
  833.                          {  is_pos[i] = scalefac[1].l[sfb];
  834.                              if (is_pos[i] != 7)
  835.                            is_ratio[i] = TAN12[is_pos[i]];
  836.  
  837.                              i++;
  838.                          }
  839.                      }
  840.                 }
  841.             } else
  842.             {  for (j=0; j<3; j++)
  843.                 {  int32 sfbcnt;
  844.                     sfbcnt = -1;
  845.                     for( sfb=12; sfb >=0; sfb-- )
  846.                     {
  847.                         temp = sfBandIndex[sfreq].s[sfb];
  848.                   lines = sfBandIndex[sfreq].s[sfb+1] - temp;
  849.                   i = (temp << 2) - temp + (j+1) * lines - 1;
  850.  
  851.                         while ( lines > 0 )
  852.                         {  if (ro[1][i/SSLIMIT][i%SSLIMIT] != 0.0f)
  853.                             {  sfbcnt = sfb;
  854.                                 sfb = -10;
  855.                                 lines = -10;
  856.                             }
  857.                             lines--;
  858.                             i--;
  859.                         }
  860.                     }
  861.                     sfb = sfbcnt + 1;
  862.                     while( sfb<12 )
  863.                     {
  864.                         temp = sfBandIndex[sfreq].s[sfb];
  865.                   sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  866.                   i    = (temp << 2) - temp + j * sb;
  867.                         for ( ; sb > 0; sb--)
  868.                         {  is_pos[i] = scalefac[1].s[j][sfb];
  869.                             if (is_pos[i] != 7)
  870.                               is_ratio[i] = TAN12[is_pos[i]];
  871.  
  872.                             i++;
  873.                         }
  874.                         sfb++;
  875.                     }
  876.  
  877.                     temp = sfBandIndex[sfreq].s[10];
  878.                temp2= sfBandIndex[sfreq].s[11];
  879.                sb   = temp2 - temp;
  880.                sfb  = (temp << 2) - temp + j * sb;
  881.                sb   = sfBandIndex[sfreq].s[12] - temp2;
  882.                i    = (temp2 << 2) - temp2 + j * sb;
  883.  
  884.                     for (; sb>0; sb--)
  885.                     {  is_pos[i] = is_pos[sfb];
  886.                         is_ratio[i] = is_ratio[sfb];
  887.                         i++;
  888.                     }
  889.                 }
  890.             }
  891.         } else // ms-stereo
  892.         {  i = 31;
  893.             ss = 17;
  894.             sb = 0;
  895.             while (i >= 0)
  896.             {  if (ro[1][i][ss] != 0.0f)
  897.                 {
  898.                 sb = (i<<4) + (i<<1) + ss;
  899.                     i = -1;
  900.                 } else
  901.                 {  ss--;
  902.                     if (ss < 0)
  903.                     {  i--;
  904.                         ss = 17;
  905.                     }
  906.                 }
  907.             }
  908.             i = 0;
  909.             while ( sfBandIndex[sfreq].l[i] <= sb )
  910.                 i++;
  911.             sfb = i;
  912.             i = sfBandIndex[sfreq].l[i];
  913.             for ( ; sfb<21; sfb++ )
  914.             {  sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  915.                 for ( ; sb > 0; sb--)
  916.                 {  is_pos[i] = scalefac[1].l[sfb];
  917.                     if (is_pos[i] != 7)
  918.                    is_ratio[i] = TAN12[is_pos[i]];
  919.  
  920.                     i++;
  921.                 }
  922.             }
  923.             sfb = sfBandIndex[sfreq].l[20];
  924.             for ( sb = 576 - sfBandIndex[sfreq].l[21]; sb > 0; sb-- )
  925.             {  is_pos[i] = is_pos[sfb];
  926.                 is_ratio[i] = is_ratio[sfb];
  927.                 i++;
  928.             }
  929.         }
  930.     }
  931.  
  932.        i = 0;
  933.         for(sb=0;sb<SBLIMIT;sb++)
  934.             for(ss=0;ss<SSLIMIT;ss++) {
  935.                 if (is_pos[i] == 7) {
  936.                     if (ms_stereo) {
  937.                         lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss]) * 0.707106781f;
  938.                         lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss]) * 0.707106781f;
  939.                     }
  940.                     else {
  941.                         lr[0][sb][ss] = ro[0][sb][ss];
  942.                         lr[1][sb][ss] = ro[1][sb][ss];
  943.                     }
  944.                 }
  945.                 else if (i_stereo) {
  946.                lr[1][sb][ss] = ro[0][sb][ss] / (real) (1 + is_ratio[i]);
  947.                      lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
  948.                 }
  949. /*                else {
  950.                     printf("Error in stereo processing\n");
  951.                 } */
  952.             i++;
  953.             }
  954.  
  955.     } // channels == 2
  956. }
  957.  
  958. real Ci[8]={-0.6f,-0.535f,-0.33f,-0.185f,-0.095f,-0.041f,-0.0142f,-0.0037f};
  959.  
  960. void LayerIII_Decoder::antialias(uint32 ch, uint32 gr)
  961. {
  962.      static real   ca[8],cs[8];
  963.      static BOOL   antialias_init = FALSE;
  964.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  965.    real *hi, *hi1;
  966.    real *ho, *ho1;
  967.  
  968.     if (!antialias_init) {
  969.         for (int32 i=0;i<8;i++) {
  970.             real sq = sqrt(1.0f + Ci[i]*Ci[i]);
  971.             cs[i] = 1.0f/sq;
  972.          ca[i] = Ci[i] * cs[i];
  973.         }
  974.         antialias_init = TRUE;
  975.     }
  976.  
  977.     // 31 alias-reduction operations between each pair of sub-bands
  978.     // with 8 butterflies between each pair
  979.  
  980.     if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  981.          !gr_info->mixed_block_flag ) {
  982.  
  983.        for(uint32 sb=0;sb<SBLIMIT;sb++) {
  984.           hi    = hybridIn[sb];    ho    = re_hybridOut[sb];
  985.             hi[0] = ho[0];             hi[1] = ho[1];
  986.             hi[2] = ho[2];               hi[3] = ho[3];
  987.             hi[4] = ho[4];            hi[5] = ho[5];
  988.             hi[6] = ho[6];            hi[7] = ho[7];
  989.             hi[8] = ho[8];            hi[9] = ho[9];
  990.             hi[10]= ho[10];            hi[11]= ho[11];
  991.             hi[12]= ho[12];            hi[13]= ho[13];
  992.             hi[14]= ho[14];            hi[15]= ho[15];
  993.            hi[16]= ho[16];            hi[17]= ho[17];
  994.       }
  995.  
  996.     } else if (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  997.       (gr_info->block_type == 2)) {
  998.  
  999.       hi    = hybridIn[0];        ho    = re_hybridOut[0];
  1000.       hi[0] = ho[0];             hi[1] = ho[1];
  1001.       hi[2] = ho[2];               hi[3] = ho[3];
  1002.       hi[4] = ho[4];            hi[5] = ho[5];
  1003.       hi[6] = ho[6];            hi[7] = ho[7];
  1004.       hi[8] = ho[8];            hi[9] = ho[9];
  1005.  
  1006.       hi1 = hybridIn[1];      ho1 = re_hybridOut[1];
  1007.  
  1008.       for(uint32 ss=0;ss<8;ss++) {
  1009.             real bu = ho[17-ss];
  1010.             real bd = ho1[ss];
  1011.             hi[17-ss] = (bu * cs[ss]) - (bd * ca[ss]);
  1012.             hi1[ss]   = (bd * cs[ss]) + (bu * ca[ss]);
  1013.       }
  1014.  
  1015.       hi1[8]  = ho1[8];         hi1[9]  = ho1[9];
  1016.       hi1[10] = ho1[10];        hi1[11] = ho1[11];
  1017.       hi1[12] = ho1[12];        hi1[13] = ho1[13];
  1018.       hi1[14] = ho1[14];        hi1[15] = ho1[15];
  1019.       hi1[16] = ho1[16];        hi1[17] = ho1[17];
  1020.  
  1021.         for(uint32 sb=2;sb<SBLIMIT;sb++) {
  1022.           hi    = hybridIn[sb];   ho    = re_hybridOut[sb];
  1023.             hi[0] = ho[0];          hi[1] = ho[1];
  1024.             hi[2] = ho[2];            hi[3] = ho[3];
  1025.             hi[4] = ho[4];            hi[5] = ho[5];
  1026.             hi[6] = ho[6];            hi[7] = ho[7];
  1027.             hi[8] = ho[8];            hi[9] = ho[9];
  1028.             hi[10]= ho[10];            hi[11]= ho[11];
  1029.             hi[12]= ho[12];            hi[13]= ho[13];
  1030.             hi[14]= ho[14];            hi[15]= ho[15];
  1031.             hi[16]= ho[16];            hi[17]= ho[17];
  1032.       }
  1033.  
  1034.     } else {
  1035.  
  1036.        hi    = hybridIn[0];    ho    = re_hybridOut[0];
  1037.       hi[0] = ho[0];            hi[1] = ho[1];
  1038.       hi[2] = ho[2];       hi[3] = ho[3];
  1039.       hi[4] = ho[4];       hi[5] = ho[5];
  1040.       hi[6] = ho[6];       hi[7] = ho[7];
  1041.  
  1042.         for(uint32 sb=0; sb < (SBLIMIT - 1); sb++) {
  1043.           hi  = hybridIn[sb];      ho  = re_hybridOut[sb];
  1044.          hi1 = hybridIn[sb+1];  ho1 = re_hybridOut[sb+1];
  1045.  
  1046.             for(uint32 ss=0;ss<8;ss++) {
  1047.                 real bu = ho[17-ss];
  1048.                 real bd = ho1[ss];
  1049.                 hi[17-ss]  = (bu * cs[ss]) - (bd * ca[ss]);
  1050.                 hi1[ss]    = (bd * cs[ss]) + (bu * ca[ss]);
  1051.             }
  1052.  
  1053.          hi[8]   = ho[8];   hi[9]   = ho[9];
  1054.       }
  1055.       // now hi1 = hybridIn[31] and ho1 = re_hybridOut[31]
  1056.       hi1[8]  = ho1[8];     hi1[9]  = ho1[9];
  1057.       hi1[10] = ho1[10];    hi1[11] = ho1[11];
  1058.       hi1[12] = ho1[12];    hi1[13] = ho1[13];
  1059.       hi1[14] = ho1[14];    hi1[15] = ho1[15];
  1060.       hi1[16] = ho1[16];    hi1[17] = ho1[17];
  1061.    }
  1062. }
  1063.  
  1064. void LayerIII_Decoder::hybrid(uint32 ch, uint32 gr)
  1065. {
  1066.     real rawout[36];
  1067.    uint32 bt;
  1068.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1069.    real *tsOut;
  1070.    real *prvblk;
  1071.  
  1072.    for(uint32 sb=0;sb<SBLIMIT;sb++) {
  1073.  
  1074.         bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1075.                  (sb < 2)) ? 0 : gr_info->block_type;
  1076.  
  1077.         inv_mdct(hybridIn[sb], rawout, bt);
  1078.  
  1079.         // overlap addition
  1080.  
  1081.        tsOut  = re_hybridOut[sb];
  1082.        prvblk = prevblck[ch][sb];
  1083.  
  1084.        tsOut[0]   = rawout[0]  + prvblk[0];
  1085.        prvblk[0]  = rawout[18];
  1086.        tsOut[1]   = rawout[1]  + prvblk[1];
  1087.        prvblk[1]  = rawout[19];
  1088.        tsOut[2]   = rawout[2]  + prvblk[2];
  1089.        prvblk[2]  = rawout[20];
  1090.        tsOut[3]   = rawout[3]  + prvblk[3];
  1091.        prvblk[3]  = rawout[21];
  1092.        tsOut[4]   = rawout[4]  + prvblk[4];
  1093.        prvblk[4]  = rawout[22];
  1094.        tsOut[5]   = rawout[5]  + prvblk[5];
  1095.        prvblk[5]  = rawout[23];
  1096.        tsOut[6]   = rawout[6]  + prvblk[6];
  1097.        prvblk[6]  = rawout[24];
  1098.        tsOut[7]   = rawout[7]  + prvblk[7];
  1099.        prvblk[7]  = rawout[25];
  1100.        tsOut[8]   = rawout[8]  + prvblk[8];
  1101.        prvblk[8]  = rawout[26];
  1102.        tsOut[9]   = rawout[9]  + prvblk[9];
  1103.        prvblk[9]  = rawout[27];
  1104.        tsOut[10]  = rawout[10] + prvblk[10];
  1105.        prvblk[10] = rawout[28];
  1106.        tsOut[11]  = rawout[11] + prvblk[11];
  1107.       prvblk[11] = rawout[29];
  1108.        tsOut[12]  = rawout[12] + prvblk[12];
  1109.        prvblk[12] = rawout[30];
  1110.        tsOut[13]  = rawout[13] + prvblk[13];
  1111.        prvblk[13] = rawout[31];
  1112.        tsOut[14]  = rawout[14] + prvblk[14];
  1113.        prvblk[14] = rawout[32];
  1114.        tsOut[15]  = rawout[15] + prvblk[15];
  1115.        prvblk[15] = rawout[33];
  1116.        tsOut[16]  = rawout[16] + prvblk[16];
  1117.        prvblk[16] = rawout[34];
  1118.        tsOut[17]  = rawout[17] + prvblk[17];
  1119.        prvblk[17] = rawout[35];
  1120.    }
  1121. }
  1122.  
  1123. void LayerIII_Decoder::do_downmix()
  1124. {
  1125.     for (uint32 sb=0; sb<SSLIMIT; sb++)
  1126.        for (uint32 ss=0; ss<SSLIMIT; ss+=3) {
  1127.           lr[0][sb][ss]   = (lr[0][sb][ss]   + lr[1][sb][ss])   * 0.5f;
  1128.           lr[0][sb][ss+1] = (lr[0][sb][ss+1] + lr[1][sb][ss+1]) * 0.5f;
  1129.           lr[0][sb][ss+2] = (lr[0][sb][ss+2] + lr[1][sb][ss+2]) * 0.5f;
  1130.       }
  1131. }
  1132.  
  1133. void LayerIII_Decoder::decode()
  1134. {
  1135.      uint32 nSlots = header->slots();
  1136.     int32 main_data_end;
  1137.      int32 bytes_to_discard;
  1138.  
  1139.      get_side_info();
  1140.  
  1141.     for (uint32 i=0; i<nSlots; i++)
  1142.         br->hputbuf((uint32) stream->get_bits(8));
  1143.  
  1144.     main_data_end = br->hsstell() >> 3; // of previous frame
  1145.  
  1146.     if (uint32 flush_main = (br->hsstell() & 0x7)) {
  1147.          br->hgetbits(8 - flush_main);
  1148.             main_data_end++;
  1149.      }
  1150.  
  1151.      bytes_to_discard = frame_start - main_data_end
  1152.                               - si->main_data_begin;
  1153.  
  1154.      frame_start += nSlots;
  1155.  
  1156.     if (bytes_to_discard < 0)
  1157.             return;
  1158.  
  1159.      if (main_data_end > 4096) {
  1160.             frame_start -= 4096;
  1161.             br->rewindNbytes(4096);
  1162.      }
  1163.  
  1164.      for (; bytes_to_discard > 0; bytes_to_discard--)
  1165.             br->hgetbits(8);
  1166.  
  1167.      for (uint32 gr=0;gr<max_gr;gr++) {
  1168.  
  1169.             for (uint32 ch=0; ch<channels; ch++) {
  1170.            part2_start = br->hsstell();
  1171.               get_scale_factors(ch, gr);
  1172.               huffman_decode(ch, gr);
  1173.               dequantize_sample(ro[ch], ch, gr);
  1174.             }
  1175.  
  1176.             stereo(gr);
  1177.  
  1178.          if ((which_channels == downmix) && (channels > 1))
  1179.             do_downmix();
  1180.  
  1181.             for (uint32 ch=first_channel; ch<=last_channel; ch++) {
  1182.  
  1183.                     reorder (lr[ch], ch, gr);
  1184.                     antialias(ch, gr);
  1185.                hybrid(ch, gr);
  1186.  
  1187.                     for (uint32 ss=1;ss<SSLIMIT;ss+=2) // Frequency inversion
  1188.                           for (uint32 sb=1;sb<SBLIMIT;sb+=2)
  1189.                                   re_hybridOut[sb][ss] = -re_hybridOut[sb][ss];
  1190.  
  1191.                     if ((ch == 0) || (which_channels == right)) {
  1192.                       for (uint32 ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1193.                             for (uint32 sb=0;sb<SBLIMIT;sb++)
  1194.                                 filter1->input_sample(re_hybridOut[sb][ss], sb);
  1195.  
  1196.                             filter1->calculate_pcm_samples(buffer);
  1197.                       }
  1198.                     } else {
  1199.                       for (uint32 ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1200.                             for (uint32 sb=0;sb<SBLIMIT;sb++)
  1201.                                 filter2->input_sample(re_hybridOut[sb][ss], sb);
  1202.  
  1203.                             filter2->calculate_pcm_samples(buffer);
  1204.                       }
  1205.                }
  1206.             }    // channels
  1207.      }    // granule
  1208.        buffer->write_buffer(1);
  1209. }
  1210.  
  1211.